I think you can do fn impression_enriching_params(&self) -> [(&str, &str); 1] to have zero allocation (no Vec, no String)

The problem with the &str (or any reference returned) in there is that this result is used during the mutable borrow of callbacks_mut, so those would have to be cloned anyway. I think returning something like Option<IntoIterator<(String, String)>> should be possible and avoid allocation in the non-spoc case and just a single small array in the spoc case.

I just went ahead and simplified it instead of worrying about iterators or refs. Now there is just a method that returns an optional cap_key, by default None, and spoc returns a string. The string would need to be owned eventually like i mentioned because of the mutable borrow for callbacks. so I figured just returning the string made more sense than making the caller do something like:

let cap_key = ad.cap_key().map(String::from)

Since we already have the request_hash acting as a unique identifier up top, could storing it in the SQLite table "impression_log" be a cleaner alternative here?

A request hash maps to an an ad response, each of which contains 0-* spocs. Each spoc has its own cap key. So going just from the request hash to a single cap key doesn't work.

A much messier thing that could be done would be to just map the impression url itself to the block key, but that is assuming that the mapping between spoc:impression url:cap key is always 1:1:1. Actually getting back to the cap key directly makes the fewest assumptions and allows the cap keys to do more complex things from the server like "all of these spocs have cap key A, and these have cap key B" to have group limits instead of just per individual spoc.